home *** CD-ROM | disk | FTP | other *** search
/ Champak 147 / (Vol 147) Jan 21 2012.iso / Interface / it.dig / scripts / __Packages / mx / controls / DataGrid.as < prev    next >
Text File  |  2012-01-21  |  38KB  |  1,224 lines
  1. class mx.controls.DataGrid extends mx.controls.List
  2. {
  3.    static var symbolOwner = mx.controls.DataGrid;
  4.    static var symbolName = "DataGrid";
  5.    static var version = "2.0.2.127";
  6.    var className = "DataGrid";
  7.    var selectable = true;
  8.    var resizableColumns = true;
  9.    var __showHeaders = true;
  10.    var sortableColumns = true;
  11.    var autoHScrollAble = true;
  12.    var editable = false;
  13.    var minColWidth = 20;
  14.    var totColW = 0;
  15.    var __rowRenderer = "DataGridRow";
  16.    var __headerHeight = 20;
  17.    var hasDrawn = false;
  18.    var minScrollInterval = 60;
  19.    var HEADERDEPTH = 5001;
  20.    var LINEDEPTH = 5000;
  21.    var SORTARROWDEPTH = 5500;
  22.    var EDITORDEPTH = 5002;
  23.    var DISABLEDHEADERDEPTH = 5003;
  24.    var HEADERCELLDEPTH = 4500;
  25.    var HEADEROVERLAYDEPTH = 4000;
  26.    var SEPARATORDEPTH = 5000;
  27.    var STRETCHERDEPTH = 1000;
  28.    function DataGrid()
  29.    {
  30.       super();
  31.    }
  32.    function init()
  33.    {
  34.       super.init();
  35.       this.invInitHeaders = true;
  36.       this.columns = new Array();
  37.    }
  38.    function layoutContent(x, y, tW, tH, dW, dH)
  39.    {
  40.       var _loc3_ = this.__rowCount;
  41.       if(this.__showHeaders)
  42.       {
  43.          y += this.__headerHeight;
  44.          dH -= this.__headerHeight;
  45.       }
  46.       super.layoutContent(x,y,tW,tH,dW,dH);
  47.       if(tW != this.totColW)
  48.       {
  49.          this.drawHeaderBG();
  50.       }
  51.       if(this.__rowCount > _loc3_)
  52.       {
  53.          this.invDrawCols = true;
  54.          this.invalidate();
  55.       }
  56.    }
  57.    function setRowCount(rC)
  58.    {
  59.       if(isNaN(rC))
  60.       {
  61.          return undefined;
  62.       }
  63.       var _loc2_ = this.getViewMetrics();
  64.       this.setSize(this.__width,this.__rowHeight * rC + _loc2_.top + _loc2_.bottom + this.__headerHeight * this.__showHeaders);
  65.    }
  66.    function setRowHeight(rH)
  67.    {
  68.       this.__rowHeight = rH;
  69.       if(this.hasDrawn)
  70.       {
  71.          super.setRowHeight(rH);
  72.       }
  73.    }
  74.    function setHScrollPolicy(policy)
  75.    {
  76.       super.setHScrollPolicy(policy);
  77.       this.invCheckCols = true;
  78.       this.invalidate();
  79.    }
  80.    function setEnabled(v)
  81.    {
  82.       if(v == this.enabled)
  83.       {
  84.          return undefined;
  85.       }
  86.       super.setEnabled(v);
  87.       if(this.__showHeaders)
  88.       {
  89.          this.enableHeader(v);
  90.       }
  91.       if(this.cellEditor._visible == true)
  92.       {
  93.          this.disposeEditor();
  94.       }
  95.       this.invDrawCols = true;
  96.       this.invalidate();
  97.    }
  98.    function modelChanged(eventObj)
  99.    {
  100.       if(eventObj.eventName == "updateField")
  101.       {
  102.          var _loc3_ = eventObj.firstItem;
  103.          var _loc5_ = this.__dataProvider.getItemAt(_loc3_);
  104.          this.rows[_loc3_ - this.__vPosition].drawRow(_loc5_,this.getStateAt(_loc3_));
  105.          return undefined;
  106.       }
  107.       if(eventObj.eventName == "schemaLoaded")
  108.       {
  109.          this.removeAllColumns();
  110.       }
  111.       if(this.columns.length == 0)
  112.       {
  113.          this.generateCols();
  114.       }
  115.       super.modelChanged(eventObj);
  116.    }
  117.    function configureScrolling(Void)
  118.    {
  119.       var _loc3_ = this.getViewMetrics();
  120.       var _loc4_ = this.__hScrollPolicy == "off" ? this.__width - _loc3_.left - _loc3_.right : this.__maxHPosition + this.__width - _loc3_.left - _loc3_.right;
  121.       var _loc2_ = this.__dataProvider.length;
  122.       if(_loc2_ == undefined)
  123.       {
  124.          _loc2_ = 0;
  125.       }
  126.       if(this.__vPosition > Math.max(0,_loc2_ - this.getRowCount() + this.roundUp))
  127.       {
  128.          this.setVPosition(Math.max(0,Math.min(_loc2_ - this.getRowCount() + this.roundUp,this.__vPosition)));
  129.       }
  130.       this.setScrollProperties(_loc4_,1,_loc2_,this.__rowHeight,this.__headerHeight * this.__showHeaders);
  131.       if(this.oldVWidth != _loc4_)
  132.       {
  133.          this.invLayoutContent = true;
  134.       }
  135.       this.oldVWidth = _loc4_;
  136.    }
  137.    function setVPosition(pos)
  138.    {
  139.       if(this.cellEditor != undefined)
  140.       {
  141.          this.disposeEditor();
  142.       }
  143.       super.setVPosition(pos);
  144.    }
  145.    function size(Void)
  146.    {
  147.       if(this.hasDrawn != true)
  148.       {
  149.          this.border_mc.setSize(this.__width,this.__height);
  150.          return undefined;
  151.       }
  152.       if(this.cellEditor != undefined)
  153.       {
  154.          this.disposeEditor();
  155.       }
  156.       if(this.__hScrollPolicy != "off")
  157.       {
  158.          var _loc5_ = 0;
  159.          var _loc6_ = this.columns.length;
  160.          var _loc3_ = 0;
  161.          while(_loc3_ < _loc6_)
  162.          {
  163.             _loc5_ += this.columns[_loc3_].__width;
  164.             _loc3_ = _loc3_ + 1;
  165.          }
  166.          var _loc8_ = this.getViewMetrics();
  167.          var _loc9_ = this.__width - _loc8_.left - _loc8_.right;
  168.          this.setMaxHPosition(Math.max(_loc5_ - _loc9_,0));
  169.          var _loc7_ = _loc9_ - _loc5_;
  170.          if(_loc7_ > 0)
  171.          {
  172.             this.columns[_loc6_ - 1].__width += _loc7_;
  173.          }
  174.          this.setHPosition(Math.min(this.getMaxHPosition(),this.getHPosition()));
  175.       }
  176.       super.size();
  177.       if(this.__hScrollPolicy == "off")
  178.       {
  179.          var _loc10_ = new Array();
  180.          _loc6_ = this.columns.length;
  181.          if(this.oldWidth == undefined)
  182.          {
  183.             this.oldWidth = this.displayWidth;
  184.          }
  185.          var _loc4_ = 0;
  186.          _loc3_ = 0;
  187.          while(_loc3_ < _loc6_)
  188.          {
  189.             _loc4_ += this.columns[_loc3_].__width = this.displayWidth * this.columns[_loc3_].__width / this.oldWidth;
  190.             _loc3_ = _loc3_ + 1;
  191.          }
  192.          if(_loc4_ != this.displayWidth)
  193.          {
  194.             this.columns[this.columns.length - 1].__width += this.displayWidth - _loc4_;
  195.          }
  196.          this.totColW = this.numberOfCols = this.displayWidth;
  197.       }
  198.       this.oldWidth = this.displayWidth;
  199.       this.drawColumns();
  200.       this.drawHeaderBG();
  201.       this.invalidate();
  202.    }
  203.    function draw()
  204.    {
  205.       if(this.invRowHeight)
  206.       {
  207.          super.draw();
  208.          this.invInitHeaders = true;
  209.          this.invDrawCols = true;
  210.          delete this.cellEditor;
  211.       }
  212.       if(this.invInitHeaders)
  213.       {
  214.          this.initHeaders();
  215.          this.invLayoutContent = true;
  216.       }
  217.       super.draw();
  218.       if(this.invSpaceColsEqually)
  219.       {
  220.          delete this.invSpaceColsEqually;
  221.          this.spaceColumnsEqually();
  222.       }
  223.       if(this.invColChange)
  224.       {
  225.          delete this.invColChange;
  226.          if(this.hasDrawn)
  227.          {
  228.             this.initHeaders();
  229.             this.initRows();
  230.             this.invDrawCols = true;
  231.             this.updateControl();
  232.             this.invCheckCols = true;
  233.          }
  234.       }
  235.       if(this.invCheckCols)
  236.       {
  237.          if(this.totColW != this.displayWidth)
  238.          {
  239.             this.resizeColumn(this.columns.length - 1,this.columns[this.columns.length - 1].__width);
  240.          }
  241.          delete this.invCheckCols;
  242.       }
  243.       if(this.invDrawCols)
  244.       {
  245.          this.drawColumns();
  246.       }
  247.       this.hasDrawn = true;
  248.    }
  249.    function editField(index, colName, data)
  250.    {
  251.       this.__dataProvider.editField(index,colName,data);
  252.    }
  253.    function get columnNames()
  254.    {
  255.       return this.getColumnNames();
  256.    }
  257.    function set columnNames(w)
  258.    {
  259.       this.setColumnNames(w);
  260.    }
  261.    function setColumnNames(tmpArray)
  262.    {
  263.       var _loc2_ = 0;
  264.       while(_loc2_ < tmpArray.length)
  265.       {
  266.          this.addColumn(tmpArray[_loc2_]);
  267.          _loc2_ = _loc2_ + 1;
  268.       }
  269.    }
  270.    function getColumnNames(Void)
  271.    {
  272.       var _loc3_ = new Array();
  273.       var _loc2_ = 0;
  274.       while(_loc2_ < this.columns.length)
  275.       {
  276.          _loc3_[_loc2_] = this.columns[_loc2_].columnName;
  277.          _loc2_ = _loc2_ + 1;
  278.       }
  279.       return _loc3_;
  280.    }
  281.    function addColumnAt(index, newCol)
  282.    {
  283.       if(index < this.columns.length)
  284.       {
  285.          this.columns.splice(index,0,"tmp");
  286.       }
  287.       var _loc4_ = newCol;
  288.       if(!(_loc4_ instanceof mx.controls.gridclasses.DataGridColumn))
  289.       {
  290.          _loc4_ = new mx.controls.gridclasses.DataGridColumn(_loc4_);
  291.       }
  292.       this.columns[index] = _loc4_;
  293.       _loc4_.colNum = index;
  294.       var _loc2_ = index + 1;
  295.       while(_loc2_ < this.columns.length)
  296.       {
  297.          this.columns[_loc2_].colNum = this.columns[_loc2_].colNum + 1;
  298.          _loc2_ = _loc2_ + 1;
  299.       }
  300.       _loc4_.parentGrid = this;
  301.       this.totColW += _loc4_.width;
  302.       this.invColChange = true;
  303.       this.invalidate();
  304.       return newCol;
  305.    }
  306.    function addColumn(newCol)
  307.    {
  308.       return this.addColumnAt(this.columns.length,newCol);
  309.    }
  310.    function removeColumnAt(index)
  311.    {
  312.       var _loc4_ = this.columns[index];
  313.       this.columns.splice(index,1);
  314.       this.totColW -= _loc4_.width;
  315.       var _loc2_ = index;
  316.       while(_loc2_ < this.columns.length)
  317.       {
  318.          this.columns[_loc2_].colNum--;
  319.          _loc2_ = _loc2_ + 1;
  320.       }
  321.       this.invColChange = true;
  322.       this.invalidate();
  323.       return _loc4_;
  324.    }
  325.    function removeAllColumns(Void)
  326.    {
  327.       this.totColW = 0;
  328.       this.columns = new Array();
  329.       this.invColChange = true;
  330.       this.invalidate();
  331.    }
  332.    function getColumnAt(index)
  333.    {
  334.       return this.columns[index];
  335.    }
  336.    function getColumnIndex(name)
  337.    {
  338.       var _loc2_ = 0;
  339.       while(_loc2_ < this.columns.length)
  340.       {
  341.          if(this.columns[_loc2_].columnName == name)
  342.          {
  343.             return _loc2_;
  344.          }
  345.          _loc2_ = _loc2_ + 1;
  346.       }
  347.    }
  348.    function get columnCount()
  349.    {
  350.       return this.columns.length;
  351.    }
  352.    function spaceColumnsEqually(Void)
  353.    {
  354.       if(this.displayWidth == undefined)
  355.       {
  356.          var _loc4_ = this.getViewMetrics();
  357.          this.displayWidth = this.__width - _loc4_.left - _loc4_.right;
  358.       }
  359.       var _loc3_ = Math.ceil(this.totalWidth / this.columns.length);
  360.       var _loc2_ = 0;
  361.       while(_loc2_ < this.columns.length)
  362.       {
  363.          this.columns[_loc2_].__width = _loc3_;
  364.          _loc2_ = _loc2_ + 1;
  365.       }
  366.       this.totColW = this.totalWidth;
  367.       this.invDrawCols = true;
  368.       this.invalidate();
  369.    }
  370.    function generateCols(Void)
  371.    {
  372.       if(this.columns.length == 0)
  373.       {
  374.          var _loc3_ = this.__dataProvider.getColumnNames();
  375.          if(_loc3_ == undefined)
  376.          {
  377.             var _loc4_ = this.__dataProvider.getItemAt(0);
  378.             for(var _loc2_ in _loc4_)
  379.             {
  380.                if(_loc2_ != "__ID__")
  381.                {
  382.                   this.addColumn(_loc2_);
  383.                }
  384.             }
  385.          }
  386.          else
  387.          {
  388.             _loc2_ = 0;
  389.             while(_loc2_ < _loc3_.length)
  390.             {
  391.                this.addColumn(_loc3_[_loc2_]);
  392.                _loc2_ = _loc2_ + 1;
  393.             }
  394.          }
  395.          this.invSpaceColsEqually = true;
  396.          this.invColChange = true;
  397.          this.invCheckCols = true;
  398.          this.invalidate();
  399.       }
  400.    }
  401.    function resizeColumn(col, w)
  402.    {
  403.       if(this.__hScrollPolicy == "on" || this.__hScrollPolicy == "auto")
  404.       {
  405.          this.columns[col].__width = w;
  406.          var _loc11_ = 0;
  407.          var _loc5_ = this.columns.length;
  408.          var _loc2_ = 0;
  409.          while(_loc2_ < _loc5_)
  410.          {
  411.             _loc11_ += this.columns[_loc2_].__width;
  412.             _loc2_ = _loc2_ + 1;
  413.          }
  414.          this.setMaxHPosition(Math.max(_loc11_ - this.displayWidth,0));
  415.          var _loc12_ = this.displayWidth - _loc11_;
  416.          if(_loc12_ > 0)
  417.          {
  418.             this.columns[_loc5_ - 1].__width += _loc12_;
  419.          }
  420.          this.setHPosition(Math.min(this.getMaxHPosition(),this.getHPosition()));
  421.          this.invDrawCols = true;
  422.          this.invalidate();
  423.          return undefined;
  424.       }
  425.       var _loc10_ = 0;
  426.       _loc2_ = 0;
  427.       while(_loc2_ < col)
  428.       {
  429.          _loc10_ += this.columns[_loc2_].__width;
  430.          _loc2_ = _loc2_ + 1;
  431.       }
  432.       var _loc8_ = this.displayWidth + 2 - _loc10_ - this.columns[col].__width;
  433.       var _loc6_ = this.displayWidth + 2 - _loc10_ - w;
  434.       this.columns[col].__width = w;
  435.       _loc5_ = this.columns.length;
  436.       _loc2_ = col + 1;
  437.       while(_loc2_ < _loc5_)
  438.       {
  439.          if(!this.columns[_loc2_].resizable)
  440.          {
  441.             _loc6_ -= this.columns[_loc2_].__width;
  442.             _loc8_ -= this.columns[_loc2_].__width;
  443.          }
  444.          _loc2_ = _loc2_ + 1;
  445.       }
  446.       var _loc9_ = 0;
  447.       _loc2_ = col + 1;
  448.       while(_loc2_ < _loc5_)
  449.       {
  450.          if(this.columns[_loc2_].resizable)
  451.          {
  452.             this.columns[_loc2_].__width = this.columns[_loc2_].width * _loc6_ / _loc8_;
  453.             _loc9_ += this.columns[_loc2_].__width;
  454.          }
  455.          _loc2_ = _loc2_ + 1;
  456.       }
  457.       var _loc3_ = 0;
  458.       var _loc7_ = false;
  459.       _loc2_ = _loc5_ - 1;
  460.       while(_loc2_ >= 0)
  461.       {
  462.          if(this.columns[_loc2_].resizable)
  463.          {
  464.             if(!_loc7_)
  465.             {
  466.                this.columns[_loc2_].__width += _loc6_ - _loc9_;
  467.                _loc7_ = true;
  468.             }
  469.             if(_loc3_ > 0)
  470.             {
  471.                this.columns[_loc2_].__width -= _loc3_;
  472.                _loc3_ = 0;
  473.             }
  474.             if(this.columns[_loc2_].__width < this.minColWidth)
  475.             {
  476.                _loc3_ += this.minColWidth - this.columns[_loc2_].__width;
  477.                this.columns[_loc2_].__width = this.minColWidth;
  478.             }
  479.          }
  480.          _loc2_ = _loc2_ - 1;
  481.       }
  482.       this.invDrawCols = true;
  483.       this.invalidate();
  484.    }
  485.    function drawColumns(Void)
  486.    {
  487.       delete this.invDrawCols;
  488.       var _loc0_ = null;
  489.       var _loc4_ = this.lines_mc = this.listContent.createEmptyMovieClip("lines_mc",this.LINEDEPTH);
  490.       var _loc9_ = 0.75;
  491.       var _loc5_ = 1;
  492.       var _loc15_ = this.__get__height() - 1;
  493.       var _loc12_ = this.getStyle("vGridLineColor");
  494.       var _loc14_ = this.columns.length;
  495.       this.placeSortArrow();
  496.       var _loc7_ = 0;
  497.       while(_loc7_ < _loc14_)
  498.       {
  499.          var _loc6_ = this.columns[_loc7_];
  500.          var _loc13_ = !this.enabled ? "backgroundDisabledColor" : "backgroundColor";
  501.          var _loc10_ = _loc6_.getStyle(_loc13_);
  502.          _loc9_ += _loc6_.__width;
  503.          _loc4_.moveTo(_loc5_,1);
  504.          _loc4_.lineStyle(0,_loc12_,0);
  505.          var _loc11_ = Math.floor(_loc9_);
  506.          _loc4_.lineTo(_loc11_,1);
  507.          if(_loc7_ < this.columns.length - 1 && this.getStyle("vGridLines"))
  508.          {
  509.             _loc4_.lineStyle(0,_loc12_,100);
  510.          }
  511.          _loc4_.lineTo(_loc11_,this.__get__height());
  512.          _loc4_.lineStyle(0,_loc12_,0);
  513.          _loc4_.lineTo(_loc5_,this.__get__height());
  514.          _loc4_.lineTo(_loc5_,1);
  515.          if(this.__showHeaders)
  516.          {
  517.             var _loc3_ = this.headerCells[_loc7_];
  518.             _loc3_._x = _loc5_ + 2;
  519.             _loc3_.hO._x = _loc5_;
  520.             _loc3_.setSize(_loc6_.__width - 5,Math.min(this.__headerHeight,_loc3_.getPreferredHeight()));
  521.             _loc3_.hO._width = _loc6_.__width - 2;
  522.             _loc3_.hO._height = this.__headerHeight;
  523.             _loc3_._y = (this.__headerHeight - _loc3_._height) / 2;
  524.             this.header_mc["sep" + _loc7_]._x = _loc9_ - 2;
  525.             this.listContent.disableHeader._width = this.totalWidth;
  526.          }
  527.          var _loc2_ = 0;
  528.          while(_loc2_ < this.__rowCount)
  529.          {
  530.             if(_loc7_ == 0)
  531.             {
  532.                this.rows[_loc2_].colBG.clear();
  533.             }
  534.             var _loc8_ = _loc6_.__width;
  535.             this.rows[_loc2_].drawCell(_loc7_,_loc5_,_loc8_,_loc10_);
  536.             _loc2_ = _loc2_ + 1;
  537.          }
  538.          _loc5_ = _loc9_;
  539.          _loc7_ = _loc7_ + 1;
  540.       }
  541.       if(this.getStyle("hGridLines"))
  542.       {
  543.          this.lines_mc.lineStyle(0,this.getStyle("hGridLineColor"));
  544.          _loc7_ = 1;
  545.          while(_loc7_ < this.__rowCount)
  546.          {
  547.             this.lines_mc.moveTo(4,this.rows[_loc7_]._y);
  548.             this.lines_mc.lineTo(this.totalWidth,this.rows[_loc7_]._y);
  549.             _loc7_ = _loc7_ + 1;
  550.          }
  551.       }
  552.    }
  553.    function initRows(Void)
  554.    {
  555.       var _loc2_ = 0;
  556.       while(_loc2_ < this.__rowCount)
  557.       {
  558.          this.rows[_loc2_].createCells();
  559.          _loc2_ = _loc2_ + 1;
  560.       }
  561.    }
  562.    function onRowPress(rowIndex)
  563.    {
  564.       super.onRowPress(rowIndex);
  565.       if(!this.enabled)
  566.       {
  567.          return undefined;
  568.       }
  569.       var _loc11_ = this.columns.length;
  570.       var _loc6_ = this.rows[rowIndex];
  571.       var _loc3_ = 0;
  572.       while(_loc3_ < _loc11_)
  573.       {
  574.          var _loc5_ = this.columns[_loc3_];
  575.          var _loc4_ = _loc6_._xmouse - _loc6_.cells[_loc3_]._x;
  576.          if(_loc4_ >= 0 && _loc4_ < _loc5_.__width)
  577.          {
  578.             this.dispatchEvent({type:"cellPress",columnIndex:_loc3_,view:this,itemIndex:rowIndex + this.__vPosition});
  579.             return undefined;
  580.          }
  581.          _loc3_ = _loc3_ + 1;
  582.       }
  583.    }
  584.    function get showHeaders()
  585.    {
  586.       return this.getShowHeaders();
  587.    }
  588.    function set showHeaders(w)
  589.    {
  590.       this.setShowHeaders(w);
  591.    }
  592.    function setShowHeaders(b)
  593.    {
  594.       this.__showHeaders = b;
  595.       this.invInitHeaders = true;
  596.       this.invDrawCols = true;
  597.       this.invalidate();
  598.    }
  599.    function getShowHeaders()
  600.    {
  601.       return this.__showHeaders;
  602.    }
  603.    function get headerHeight()
  604.    {
  605.       return this.getHeaderHeight();
  606.    }
  607.    function set headerHeight(w)
  608.    {
  609.       this.setHeaderHeight(w);
  610.    }
  611.    function setHeaderHeight(h)
  612.    {
  613.       this.__headerHeight = h;
  614.       this.invInitHeaders = true;
  615.       this.invDrawCols = true;
  616.       this.invalidate();
  617.    }
  618.    function getHeaderHeight(Void)
  619.    {
  620.       return this.__headerHeight;
  621.    }
  622.    function initHeaders(Void)
  623.    {
  624.       delete this.invInitHeaders;
  625.       if(this.__showHeaders)
  626.       {
  627.          this.header_mc = this.listContent.createClassObject(mx.core.UIObject,"header_mc",this.HEADERDEPTH,{styleName:this});
  628.          this.headerCells = new Array();
  629.          var _loc2_ = 0;
  630.          while(_loc2_ < this.columns.length)
  631.          {
  632.             var _loc6_ = this.columns[_loc2_];
  633.             var _loc4_ = undefined;
  634.             var _loc7_ = _loc6_.__headerRenderer;
  635.             if(_loc7_ == undefined)
  636.             {
  637.                var _loc0_ = null;
  638.                _loc4_ = this.headerCells[_loc2_] = this.header_mc.createLabel("fHeaderCell" + _loc2_,this.HEADERCELLDEPTH + _loc2_);
  639.                _loc4_.selectable = false;
  640.                _loc4_.setStyle("styleName",_loc6_);
  641.             }
  642.             else if(typeof _loc7_ == "string")
  643.             {
  644.                var _loc0_ = null;
  645.                _loc4_ = this.headerCells[_loc2_] = this.header_mc.createObject(_loc7_,"fHeaderCell" + _loc2_,this.HEADERCELLDEPTH + _loc2_,{styleName:_loc6_});
  646.             }
  647.             else
  648.             {
  649.                var _loc0_ = null;
  650.                _loc4_ = this.headerCells[_loc2_] = this.header_mc.createClassObject(_loc7_,"fHeaderCell" + _loc2_,this.HEADERCELLDEPTH + _loc2_,{styleName:_loc6_});
  651.             }
  652.             _loc4_.setValue(_loc6_.__get__headerText());
  653.             _loc6_.headerCell = _loc4_;
  654.             var _loc3_ = this.header_mc.attachMovie("DataHeaderOverlay","hO" + _loc2_,this.HEADEROVERLAYDEPTH + _loc2_);
  655.             _loc4_.hO = _loc3_;
  656.             _loc3_.cell = _loc4_;
  657.             _loc4_.column = _loc3_.column = _loc6_;
  658.             _loc4_.asc = _loc3_.asc = false;
  659.             _loc4_.owner = _loc3_.owner = this;
  660.             _loc3_._alpha = 0;
  661.             if(_loc3_.column.sortable && _loc3_.onPress == undefined)
  662.             {
  663.                _loc3_.useHandCursor = false;
  664.                _loc3_.onRollOver = this.headerRollOver;
  665.                _loc3_.onRollOut = this.headerRollOut;
  666.                _loc3_.onPress = this.headerPress;
  667.                _loc3_.onRelease = this.headerRelease;
  668.                _loc3_.onReleaseOutside = this.headerUp;
  669.                _loc3_.headerUp = this.headerUp;
  670.             }
  671.             if(_loc2_ < this.columns.length - 1)
  672.             {
  673.                var _loc5_ = this.header_mc.attachMovie("DataHeaderSeperator","sep" + _loc2_,this.SEPARATORDEPTH + _loc2_);
  674.                _loc5_._height = this.__headerHeight;
  675.                if(_loc6_.resizable && this.resizableColumns)
  676.                {
  677.                   _loc5_.useHandCursor = false;
  678.                   _loc5_.col = _loc2_;
  679.                   _loc5_.owner = this;
  680.                   _loc5_.onRollOver = this.showStretcher;
  681.                   _loc5_.onPress = this.startSizing;
  682.                   _loc5_.onRelease = _loc5_.onReleaseOutside = this.stopSizing;
  683.                   _loc5_.onRollOut = this.hideStretcher;
  684.                }
  685.             }
  686.             _loc2_ = _loc2_ + 1;
  687.          }
  688.          this.drawHeaderBG();
  689.       }
  690.       else
  691.       {
  692.          this.header_mc.removeMovieClip();
  693.       }
  694.    }
  695.    function invalidateHeaderStyle(Void)
  696.    {
  697.       var _loc4_ = this.columns.length;
  698.       var _loc3_ = 0;
  699.       while(_loc3_ < _loc4_)
  700.       {
  701.          var _loc2_ = this.headerCells[_loc3_];
  702.          if(_loc2_.stylecache != undefined)
  703.          {
  704.             delete _loc2_.stylecache.tf;
  705.          }
  706.          delete _loc2_.enabledColor;
  707.          _loc2_.invalidateStyle();
  708.          _loc2_.draw();
  709.          _loc3_ = _loc3_ + 1;
  710.       }
  711.    }
  712.    function drawHeaderBG(Void)
  713.    {
  714.       var _loc2_ = this.header_mc;
  715.       _loc2_.clear();
  716.       var _loc5_ = this.getStyle("headerColor");
  717.       var _loc3_ = this.__viewMetrics;
  718.       var _loc4_ = Math.max(this.totalWidth,this.displayWidth + 3);
  719.       _loc2_.moveTo(_loc3_.left,_loc3_.top);
  720.       var _loc7_ = {matrixType:"box",x:0,y:0,w:_loc4_,h:this.__headerHeight + 1,r:1.5707963267948966};
  721.       var _loc8_ = [_loc5_,_loc5_,16777215];
  722.       var _loc9_ = [0,60,255];
  723.       var _loc6_ = [100,100,100];
  724.       _loc2_.beginGradientFill("linear",_loc8_,_loc6_,_loc9_,_loc7_);
  725.       _loc2_.lineStyle(0,0,0);
  726.       _loc2_.lineTo(_loc4_,_loc3_.top);
  727.       _loc2_.lineTo(_loc4_,this.__headerHeight + 1);
  728.       _loc2_.lineStyle(0,0,100);
  729.       _loc2_.lineTo(_loc3_.left,this.__headerHeight + 1);
  730.       _loc2_.lineStyle(0,0,0);
  731.       _loc2_.endFill();
  732.    }
  733.    function enableHeader(v)
  734.    {
  735.       if(v)
  736.       {
  737.          this.listContent.disableHeader.removeMovieClip();
  738.       }
  739.       else
  740.       {
  741.          var _loc2_ = this.listContent.attachMovie("DataHeaderOverlay","disableHeader",this.DISABLEDHEADERDEPTH);
  742.          _loc2_._width = this.totalWidth;
  743.          _loc2_._height = this.__headerHeight;
  744.          var _loc3_ = new Color(_loc2_);
  745.          _loc3_.setRGB(this.getStyle("backgroundDisabledColor"));
  746.          _loc2_._alpha = 60;
  747.       }
  748.    }
  749.    function placeSortArrow(Void)
  750.    {
  751.       this.sortArrow.removeMovieClip();
  752.       if(this.sortIndex == undefined)
  753.       {
  754.          return undefined;
  755.       }
  756.       if(this.columns[this.sortIndex].__width - this.headerCells[this.sortIndex].getPreferredWidth() <= 20)
  757.       {
  758.          return undefined;
  759.       }
  760.       this.sortArrow = this.header_mc.createObject("DataSortArrow","sortArrow",this.SORTARROWDEPTH);
  761.       var _loc3_ = this.layoutX;
  762.       var _loc2_ = 0;
  763.       while(_loc2_ <= this.sortIndex)
  764.       {
  765.          _loc3_ += this.columns[_loc2_].__width;
  766.          _loc2_ = _loc2_ + 1;
  767.       }
  768.       var _loc4_ = this.sortDirection == "ASC";
  769.       this.sortArrow._yscale = !_loc4_ ? 100 : -100;
  770.       this.sortArrow._x = _loc3_ - this.sortArrow._width - 8;
  771.       this.sortArrow._y = (this.__headerHeight - this.sortArrow._height) / 2 + _loc4_ * this.sortArrow._height;
  772.    }
  773.    function headerRollOver(Void)
  774.    {
  775.       var _loc2_ = this.owner;
  776.       if(!_loc2_.enabled || _loc2_.cellEditor != undefined || !_loc2_.sortableColumns || !this.column.sortable)
  777.       {
  778.          return undefined;
  779.       }
  780.       var _loc3_ = new Color(this);
  781.       _loc3_.setRGB(_loc2_.getStyle("rollOverColor"));
  782.       this._alpha = 50;
  783.    }
  784.    function headerRollOut(Void)
  785.    {
  786.       this._alpha = 0;
  787.    }
  788.    function headerPress(Void)
  789.    {
  790.       var _loc2_ = this.owner;
  791.       if(!this.column.sortable || !_loc2_.sortableColumns || !_loc2_.enabled)
  792.       {
  793.          return undefined;
  794.       }
  795.       this.cell._x += 1;
  796.       this.cell._y += 1;
  797.       var _loc3_ = new Color(this);
  798.       _loc3_.setRGB(_loc2_.getStyle("selectionColor"));
  799.       this._alpha = 100;
  800.    }
  801.    function headerUp(Void)
  802.    {
  803.       if(!this.column.sortable || !this.owner.sortableColumns || !this.owner.enabled)
  804.       {
  805.          return undefined;
  806.       }
  807.       this._alpha = 0;
  808.       this.cell._x -= 1;
  809.       this.cell._y -= 1;
  810.    }
  811.    function headerRelease(Void)
  812.    {
  813.       var _loc2_ = this.owner;
  814.       var _loc3_ = this.column;
  815.       if(!_loc3_.sortable || !_loc2_.sortableColumns || !_loc2_.enabled)
  816.       {
  817.          return undefined;
  818.       }
  819.       this.headerUp();
  820.       this.asc = !this.asc;
  821.       var _loc4_ = !this.asc ? "DESC" : "ASC";
  822.       _loc2_.sortIndex = _loc2_.getColumnIndex(_loc3_.columnName);
  823.       _loc2_.sortDirection = _loc4_;
  824.       _loc2_.placeSortArrow();
  825.       if(_loc3_.sortOnHeaderRelease)
  826.       {
  827.          _loc2_.sortItemsBy(_loc3_.columnName,_loc4_);
  828.       }
  829.       _loc2_.dispatchEvent({type:"headerRelease",view:_loc2_,columnIndex:_loc2_.getColumnIndex(_loc3_.columnName)});
  830.       _loc2_.dontEdit = true;
  831.    }
  832.    function isStretchable(col)
  833.    {
  834.       var _loc2_ = true;
  835.       if(!this.resizableColumns)
  836.       {
  837.          _loc2_ = false;
  838.       }
  839.       else if(!this.columns[col].resizable)
  840.       {
  841.          _loc2_ = false;
  842.       }
  843.       else if(col == this.columns.length - 2 && !this.columns[col + 1].resizable)
  844.       {
  845.          _loc2_ = false;
  846.       }
  847.       return _loc2_;
  848.    }
  849.    function showStretcher(Void)
  850.    {
  851.       var _loc2_ = this.owner;
  852.       if(!_loc2_.isStretchable(this.col) || !_loc2_.enabled || _loc2_.cellEditor != undefined)
  853.       {
  854.          return undefined;
  855.       }
  856.       Mouse.hide();
  857.       if(_loc2_.stretcher == undefined)
  858.       {
  859.          _loc2_.attachMovie("cursorStretch","stretcher",_loc2_.STRETCHERDEPTH);
  860.       }
  861.       _loc2_.stretcher._x = _loc2_._xmouse;
  862.       _loc2_.stretcher._y = _loc2_._ymouse;
  863.       _loc2_.stretcher._visible = true;
  864.       _loc2_.onMouseMove = function()
  865.       {
  866.          this.stretcher._x = this._xmouse;
  867.          this.stretcher._y = this._ymouse;
  868.          updateAfterEvent();
  869.       };
  870.    }
  871.    function startSizing(Void)
  872.    {
  873.       var _loc2_ = this.owner;
  874.       if(!_loc2_.isStretchable(this.col) || !_loc2_.enabled)
  875.       {
  876.          return undefined;
  877.       }
  878.       _loc2_.pressFocus();
  879.       _loc2_.attachMovie("DataStretchBar","stretchBar",999);
  880.       _loc2_.stretchBar._height = _loc2_.height;
  881.       _loc2_.stretchBar._x = _loc2_._xmouse;
  882.       this.oldX = _loc2_.stretchBar._x;
  883.       _loc2_.colX = this.oldX - _loc2_.columns[this.col].width;
  884.       _loc2_.onMouseMove = function()
  885.       {
  886.          this.stretcher._x = this._xmouse;
  887.          this.stretcher._y = this._ymouse;
  888.          this.stretchBar._x = Math.max(this._xmouse,this.colX + this.minColWidth);
  889.          if(this.__hScrollPolicy == "off")
  890.          {
  891.             this.stretchBar._x = Math.min(this.stretchBar._x,this.displayWidth - this.minColWidth);
  892.          }
  893.          updateAfterEvent();
  894.       };
  895.    }
  896.    function stopSizing(Void)
  897.    {
  898.       var _loc2_ = this.owner;
  899.       var _loc3_ = this.col;
  900.       if(!_loc2_.isStretchable(_loc3_) || !_loc2_.enabled)
  901.       {
  902.          return undefined;
  903.       }
  904.       _loc2_.stretchBar._visible = false;
  905.       this.onRollOut();
  906.       var _loc4_ = _loc2_.stretchBar._x - this.oldX;
  907.       _loc2_.resizeColumn(_loc3_,_loc2_.columns[_loc3_].width + _loc4_);
  908.       _loc2_.dispatchEvent({type:"columnStretch",columnIndex:_loc3_});
  909.    }
  910.    function hideStretcher(Void)
  911.    {
  912.       this.owner.stretcher._visible = false;
  913.       delete this.owner.onMouseMove;
  914.       Mouse.show();
  915.    }
  916.    function set focusedCell(obj)
  917.    {
  918.       this.setFocusedCell(obj);
  919.    }
  920.    function get focusedCell()
  921.    {
  922.       return this.__focusedCell;
  923.    }
  924.    function setFocusedCell(coord, broadCast)
  925.    {
  926.       if(!this.enabled || !this.editable)
  927.       {
  928.          return undefined;
  929.       }
  930.       if(coord == undefined && this.cellEditor != undefined)
  931.       {
  932.          this.disposeEditor();
  933.          return undefined;
  934.       }
  935.       var _loc2_ = coord.itemIndex;
  936.       var _loc5_ = coord.columnIndex;
  937.       if(_loc2_ == undefined)
  938.       {
  939.          _loc2_ = 0;
  940.       }
  941.       if(_loc5_ == undefined)
  942.       {
  943.          _loc5_ = 0;
  944.       }
  945.       var _loc9_ = this.columns[_loc5_].columnName;
  946.       if(this.__vPosition > _loc2_)
  947.       {
  948.          this.setVPosition(_loc2_);
  949.       }
  950.       else
  951.       {
  952.          var _loc11_ = _loc2_ - this.__vPosition - this.__rowCount + this.roundUp + 1;
  953.          if(_loc11_ > 0)
  954.          {
  955.             this.setVPosition(this.__vPosition + _loc11_);
  956.          }
  957.       }
  958.       var _loc10_ = this.columns[_loc5_];
  959.       var _loc8_ = this.rows[_loc2_ - this.__vPosition];
  960.       var _loc3_ = _loc8_.cells[_loc5_];
  961.       if(_loc3_._x > this.__hPosition + this.displayWidth || _loc3_._x < this.__hPosition)
  962.       {
  963.          this.setHPosition(_loc3_._x);
  964.       }
  965.       var _loc4_ = this.__dataProvider.getEditingData(_loc2_,_loc9_);
  966.       if(_loc4_ == undefined)
  967.       {
  968.          _loc4_ = this.__dataProvider.getItemAt(_loc2_)[_loc9_];
  969.       }
  970.       if(_loc4_ == undefined)
  971.       {
  972.          _loc4_ = " ";
  973.       }
  974.       if(_loc3_.isCellEditor != true)
  975.       {
  976.          if(this.cellEditor == undefined)
  977.          {
  978.             this.cellEditor = this.listContent.createClassObject(mx.controls.TextInput,"editor_mc",this.EDITORDEPTH,{styleName:_loc10_,listOwner:this});
  979.          }
  980.          this.cellEditor.backgroundColor = 16777215;
  981.          this.cellEditor._visible = true;
  982.          this.cellEditor.setSize(_loc10_.__width,this.__rowHeight + 2);
  983.          this.cellEditor._x = _loc3_._x - 1;
  984.          this.cellEditor.text = _loc4_;
  985.          this.editorMask = this.listContent.attachMovie("BoundingBox","editorMask",60001,{_alpha:0});
  986.          this.cellEditor.setMask(this.editorMask);
  987.          this.editorMask._width = this.cellEditor.width;
  988.          this.editorMask._height = this.cellEditor.height;
  989.          this.editorMask._y = this.cellEditor._y = _loc8_._y - 1;
  990.          this.editorMask._x = this.cellEditor._x - this.editorMask._width;
  991.          this.editTween = new mx.effects.Tween(this,this.cellEditor._x - this.editorMask._width,this.cellEditor._x,150);
  992.       }
  993.       else
  994.       {
  995.          this.cellEditor = _loc3_;
  996.          this.cellEditor.setValue(_loc4_,this.__dataProvider.getItemAt(_loc2_));
  997.       }
  998.       var _loc6_ = this.getFocusManager();
  999.       _loc6_.setFocus(this.cellEditor);
  1000.       _loc6_.defaultPushButtonEnabled = false;
  1001.       if(_loc3_.isCellEditor != true)
  1002.       {
  1003.          this.cellEditor.hPosition = 0;
  1004.          this.cellEditor.redraw();
  1005.          Selection.setSelection(0,this.cellEditor.length);
  1006.       }
  1007.       this.__focusedCell = coord;
  1008.       if(this.__tabHandlerCache == undefined)
  1009.       {
  1010.          this.__tabHandlerCache = _loc6_.tabHandler;
  1011.          _loc6_.tabHandler = this.tabHandler;
  1012.       }
  1013.       _loc6_.activeGrid = this;
  1014.       this.cellEditor.addEventListener("keyDown",this.editorKeyDown);
  1015.       if(broadCast)
  1016.       {
  1017.          this.dispatchEvent({type:"cellFocusIn",itemIndex:_loc2_,columnIndex:_loc5_});
  1018.       }
  1019.    }
  1020.    function onMouseDown(Void)
  1021.    {
  1022.       if(this.cellEditor._visible && !this.cellEditor.hitTest(_root._xmouse,_root._ymouse))
  1023.       {
  1024.          this.editCell();
  1025.       }
  1026.       if(this.vScroller.hitTest(_root._xmouse,_root._ymouse) || this.hScroller.hitTest(_root._xmouse,_root._ymouse) || this.header_mc.hitTest(_root._xmouse,_root._ymouse))
  1027.       {
  1028.          this.dontEdit = true;
  1029.       }
  1030.    }
  1031.    function editorKeyDown(Void)
  1032.    {
  1033.       if(Key.isDown(27))
  1034.       {
  1035.          this.listOwner.disposeEditor();
  1036.       }
  1037.       else if(Key.isDown(13) && Key.getCode() != 229)
  1038.       {
  1039.          this.listOwner.editCell();
  1040.          this.listOwner.findNextEnterCell();
  1041.       }
  1042.    }
  1043.    function tabHandler(Void)
  1044.    {
  1045.       var _loc3_ = -1;
  1046.       var _loc4_ = -1;
  1047.       var _loc2_ = this.activeGrid;
  1048.       if(_loc2_.__focusedCell != undefined)
  1049.       {
  1050.          _loc3_ = _loc2_.__focusedCell.itemIndex;
  1051.          _loc4_ = _loc2_.__focusedCell.columnIndex;
  1052.       }
  1053.       _loc2_.editCell();
  1054.       _loc2_.findNextCell(_loc3_,_loc4_);
  1055.    }
  1056.    function findNextEnterCell(Void)
  1057.    {
  1058.       var _loc3_ = !Key.isDown(16) ? 1 : -1;
  1059.       var _loc2_ = this.__focusedCell.itemIndex + _loc3_;
  1060.       if(_loc2_ < this.getLength() && _loc2_ >= 0)
  1061.       {
  1062.          this.__focusedCell.itemIndex = _loc2_;
  1063.       }
  1064.       this.setFocusedCell(this.__focusedCell,true);
  1065.    }
  1066.    function findNextCell(index, colIndex)
  1067.    {
  1068.       if(index == undefined)
  1069.       {
  1070.          index = colIndex = -1;
  1071.       }
  1072.       var _loc5_ = false;
  1073.       var _loc4_ = !Key.isDown(16) ? 1 : -1;
  1074.       while(!_loc5_)
  1075.       {
  1076.          colIndex += _loc4_;
  1077.          if(colIndex >= this.columns.length || colIndex < 0)
  1078.          {
  1079.             colIndex = colIndex >= 0 ? 0 : this.columns.length;
  1080.             index += _loc4_;
  1081.             if(index >= this.getLength() || index < 0)
  1082.             {
  1083.                if(this.getFocusManager().activeGrid != undefined)
  1084.                {
  1085.                   this.disposeEditor();
  1086.                }
  1087.                this.dontEdit = true;
  1088.                Selection.setFocus(this);
  1089.                delete this.dontEdit;
  1090.                this.getFocusManager().tabHandler();
  1091.                return undefined;
  1092.             }
  1093.          }
  1094.          if(this.columns[colIndex].editable)
  1095.          {
  1096.             _loc5_ = true;
  1097.             if(this.__tabHandlerCache != undefined)
  1098.             {
  1099.                this.disposeEditor();
  1100.             }
  1101.             this.setFocusedCell({itemIndex:index,columnIndex:colIndex},true);
  1102.          }
  1103.       }
  1104.    }
  1105.    function onSetFocus(Void)
  1106.    {
  1107.       super.onSetFocus();
  1108.       if(this.editable && this.dontEdit != true)
  1109.       {
  1110.          if(this.__focusedCell == undefined)
  1111.          {
  1112.             this.__focusedCell = {itemIndex:0,columnIndex:0};
  1113.          }
  1114.          if(this.columns[this.__focusedCell.columnIndex].editable == true)
  1115.          {
  1116.             this.setFocusedCell(this.__focusedCell,true);
  1117.          }
  1118.          else
  1119.          {
  1120.             this.findNextCell(this.__focusedCell.itemIndex,this.__focusedCell.columnIndex);
  1121.          }
  1122.       }
  1123.       delete this.dontEdit;
  1124.    }
  1125.    function onTweenUpdate(val)
  1126.    {
  1127.       this.editorMask._x = val;
  1128.    }
  1129.    function onTweenEnd(val)
  1130.    {
  1131.       this.editorMask._x = val;
  1132.       this.cellEditor.setMask(undefined);
  1133.       this.editorMask.removeMovieClip();
  1134.    }
  1135.    function disposeEditor(Void)
  1136.    {
  1137.       this.cellEditor.removeEventListener("keyDown",this.editorKeyDown);
  1138.       this.dispatchEvent({type:"cellFocusOut",itemIndex:this.__focusedCell.itemIndex,columnIndex:this.__focusedCell.columnIndex});
  1139.       if(this.cellEditor.isCellEditor != true)
  1140.       {
  1141.          this.cellEditor._visible = false;
  1142.       }
  1143.       var _loc3_ = this.getFocusManager();
  1144.       if(this.__tabHandlerCache != undefined)
  1145.       {
  1146.          _loc3_.tabHandler = this.__tabHandlerCache;
  1147.          delete this.__tabHandlerCache;
  1148.       }
  1149.       _loc3_.defaultPushButtonEnabled = true;
  1150.       if(this.border_mc.hitTest(_root._xmouse,_root._ymouse) && !this.vScroller.hitTest(_root._xmouse,_root._ymouse) && !this.hScroller.hitTest(_root._xmouse,_root._ymouse))
  1151.       {
  1152.          this.dontEdit = true;
  1153.          this.releaseFocus();
  1154.          delete this.dontEdit;
  1155.       }
  1156.       delete this.cellEditor;
  1157.       delete _loc3_.activeGrid;
  1158.    }
  1159.    function editCell()
  1160.    {
  1161.       var _loc3_ = this.__focusedCell.itemIndex;
  1162.       var _loc4_ = this.columns[this.__focusedCell.columnIndex].columnName;
  1163.       var _loc2_ = this.__dataProvider.getEditingData(_loc3_,_loc4_);
  1164.       if(_loc2_ == undefined)
  1165.       {
  1166.          _loc2_ = this.__dataProvider.getItemAt(_loc3_)[_loc4_];
  1167.       }
  1168.       var _loc5_ = !this.cellEditor.isCellEditor ? this.cellEditor.text : this.cellEditor.getValue();
  1169.       if(_loc2_ != _loc5_)
  1170.       {
  1171.          this.editField(_loc3_,_loc4_,_loc5_);
  1172.          this.dispatchEvent({type:"cellEdit",itemIndex:_loc3_,columnIndex:this.__focusedCell.columnIndex,oldValue:_loc2_});
  1173.       }
  1174.       this.disposeEditor();
  1175.    }
  1176.    function invalidateStyle(propName)
  1177.    {
  1178.       if(propName == "headerColor" || propName == "styleName")
  1179.       {
  1180.          this.drawHeaderBG();
  1181.       }
  1182.       if(propName == "hGridLines" || propName == "hGridLineColor" || propName == "vGridLines" || propName == "vGridLineColor" || propName == "styleName" || propName == "backgroundColor")
  1183.       {
  1184.          this.invDrawCols = true;
  1185.          this.invalidate();
  1186.       }
  1187.       if(mx.styles.StyleManager.TextStyleMap[propName] != undefined)
  1188.       {
  1189.          super.changeTextStyleInChildren(propName);
  1190.       }
  1191.       if(propName == "styleName" || propName == "headerStyle")
  1192.       {
  1193.          this.invalidateHeaderStyle();
  1194.       }
  1195.       super.invalidateStyle(propName);
  1196.    }
  1197.    function notifyStyleChangeInChildren(sheetName, styleProp, newValue)
  1198.    {
  1199.       if(styleProp == "headerStyle")
  1200.       {
  1201.          this.invalidateHeaderStyle();
  1202.       }
  1203.       if(sheetName != undefined)
  1204.       {
  1205.          var _loc4_ = 0;
  1206.          while(_loc4_ < this.columns.length)
  1207.          {
  1208.             if(sheetName == this.columns[_loc4_].styleName)
  1209.             {
  1210.                this.invalidateStyle(styleProp);
  1211.                var _loc3_ = 0;
  1212.                while(_loc3_ < this.rows.length)
  1213.                {
  1214.                   this.rows[_loc3_].notifyStyleChangeInChildren(sheetName,styleProp,newValue);
  1215.                   _loc3_ = _loc3_ + 1;
  1216.                }
  1217.             }
  1218.             _loc4_ = _loc4_ + 1;
  1219.          }
  1220.       }
  1221.       super.notifyStyleChangeInChildren(sheetName,styleProp,newValue);
  1222.    }
  1223. }
  1224.